home *** CD-ROM | disk | FTP | other *** search
/ Network PC / Network PC.iso / amiga utilities / performance / memory / tinymeter / source / tinymeter_main / handler.c < prev    next >
Encoding:
C/C++ Source or Header  |  1997-11-20  |  16.7 KB  |  593 lines
  1. #include <intuition/classusr.h>
  2. #include <intuition/gadgetclass.h>
  3. #include <intuition/cghooks.h>
  4. #include <intuition/icclass.h>
  5. #include <intuition/classes.h>
  6. #include <utility/tagitem.h>
  7. #include <exec/types.h>
  8. #include <exec/memory.h>
  9. #include <dos/dos.h>
  10. #include <exec/types.h>
  11. #include <exec/memory.h>
  12. #include <dos/notify.h>
  13. #include <intuition/intuition.h>
  14. #include <libraries/SysInfo.h>
  15. #include <utility/tagitem.h>
  16. #include <clib/macros.h>
  17. #include <libraries/commodities.h>
  18. #include <libraries/ScreenNotify.h>
  19. #include "gaugeclass.h"
  20. #include "tinymeter.h"
  21.  
  22. extern struct Library *RetinaBase;
  23.  
  24. extern ULONG idle;
  25.  
  26. #define test_test       0
  27. #define test_getwin     1
  28.  
  29. #define do_clock        1
  30. #define do_mem          2
  31. #define do_vol          3
  32.  
  33. struct TestMessage
  34. {
  35.     struct  Message ts_Message;
  36.  
  37.     ULONG   MethodID;
  38.  
  39.     struct  tm_sys_set  *set;
  40.     struct  tm_gau_set  *list;
  41.  
  42.     ULONG   posx,
  43.         posy,
  44.         sizx;
  45. };
  46.  
  47. init_time_request(struct timerequest *my_time_request_clock, ULONG my_time_mask_clock)
  48. {
  49.     ULONG interval;
  50.     my_time_request_clock -> tr_node.io_Command     = TR_GETSYSTIME;
  51.     DoIO(my_time_request_clock);
  52.     interval=my_time_request_clock -> tr_time.tv_secs;
  53.     my_time_request_clock -> tr_node.io_Command     = TR_ADDREQUEST;
  54.     my_time_request_clock -> tr_time.tv_secs        = interval+1;
  55.     my_time_request_clock -> tr_time.tv_micro       = 0;
  56.     SetSignal(0,my_time_mask_clock);
  57.     SendIO(my_time_request_clock);
  58. }
  59.  
  60. ULONG snapSub(struct tm_sys_set *set, struct tm_data *data)
  61. {
  62.     struct Gadget       *g;
  63.     int                 i;
  64.  
  65.     g=data->win->FirstGadget;
  66.     data->win=(struct Window *)snapBackground(set,data);
  67.     RemoveGList(data->win,data->win->FirstGadget,-1);
  68.     AddGList(data->win,g,0,-1,NULL);
  69.     drawBackground(set,data);
  70.     for(i=0;i<data->num_of_gaug;i++)
  71.     {
  72.     if(data->gdg[i]!=0)
  73.     {
  74.         SetAttrs(data->gdg[i],GA_Width, data->gauge_x_size, NULL);
  75.         RefreshGList(data->gdg[i],data->win,NULL,1);
  76.     }
  77.     }
  78.     return(1L << data->win->UserPort->mp_SigBit);
  79. }
  80.  
  81. setBase(struct tm_data *data)
  82. {
  83.     struct tm_gau_set   *many;
  84.     int                 i;
  85.     ULONG               cur;
  86.     for(i=0,many=data->list;i<data->num_of_gaug;i++,many=many->next)
  87.     {
  88.     if(data->gdg[i]!=0)
  89.     {
  90.         GetAttr(GAU_Current,data->gdg[i],&cur);
  91.         SetAttrs(data->gdg[i],GAU_Current,cur,GAU_Base,cur,TAG_DONE);
  92.         RefreshGList(data->gdg[i],data->win,NULL,1);
  93.     }
  94.     }
  95. }
  96.  
  97. struct tm_sys_set *handler(struct tm_sys_set *set, struct tm_data *data, struct MsgPort *broker_mp, CxObj *broker, ULONG cxsigflag, Class *gclass)
  98. {
  99.     BOOL                        running = TRUE;
  100.  
  101.     ULONG                       interval,
  102.                 mem_val=0,
  103.                 vol_val=0,
  104.                 sigs,
  105.                 window_mask,
  106.                 my_time_mask_clock,
  107.                 my_test_port_mask,
  108.                 my_noti_port_mask=0L,
  109.                 my_handler;
  110.  
  111.     struct MsgPort             *my_time_port_clock,
  112.                    *my_test_port,
  113.                    *my_noti_port;
  114.  
  115.     struct timerequest         *my_time_request_clock;
  116.  
  117.     struct NotifyRequest       *notifyrequest;
  118.     LONG                        not_sig;
  119.  
  120.     struct IntuiMessage        *m;
  121.     struct Gadget              *g;
  122.     int                         i;
  123.     ULONG                       cur;
  124.     ULONG                       bas;
  125.     struct TestMessage         *test_msg;
  126.     struct tm_gau_set          *many,*next;
  127.     UBYTE                      *my_file;
  128.     BOOL                        first_run=TRUE;
  129.     UWORD                       do_what;
  130.  
  131.     if(data->scrnot)
  132.     {
  133.     my_noti_port        = (struct MsgPort *)CreateMsgPort();
  134.     my_handler          = ((!data->on_public)|(!strcmp(&set->pub_name[0],"Workbench"))) ? (ULONG)AddWorkbenchClient(my_noti_port,0) : (ULONG)AddCloseScreenClient(data->scr,my_noti_port,0);
  135.     my_noti_port_mask   = 1L << my_noti_port->mp_SigBit;
  136.     }
  137.  
  138.     window_mask  = 1L << data->win->UserPort->mp_SigBit;
  139.  
  140.     if(my_test_port=(struct MsgPort *)CreatePort("TinyMeter",0))
  141.     {
  142.     my_test_port_mask = 1L << (my_test_port->mp_SigBit);
  143.     if(my_time_port_clock=(struct MsgPort *)CreateMsgPort())
  144.     {
  145.         my_time_mask_clock    = 1L << (my_time_port_clock->mp_SigBit);
  146.         if(my_time_request_clock = (struct timerequest *)CreateIORequest(my_time_port_clock,sizeof(struct timerequest)))
  147.         {
  148.         if(!OpenDevice("timer.device",UNIT_WAITUNTIL,my_time_request_clock,NULL))
  149.         {
  150.             if(notifyrequest = (struct NotifyRequest *)AllocVec(sizeof(struct NotifyRequest), MEMF_CLEAR))
  151.             {
  152.             if ((not_sig = AllocSignal(-1L)) != -1)
  153.             {
  154.                 notifyrequest->nr_Name = "ENV:sys/WBPattern.prefs";
  155.                 notifyrequest->nr_Flags = NRF_SEND_SIGNAL;
  156.                 notifyrequest->nr_stuff.nr_Signal.nr_Task = (struct Task *) FindTask(NULL);
  157.                 notifyrequest->nr_stuff.nr_Signal.nr_SignalNum = not_sig;
  158.                 if ((StartNotify(notifyrequest)) == DOSTRUE)
  159.                 {
  160.                 init_time_request(my_time_request_clock,my_time_mask_clock);
  161.                 while(running)
  162.                 {
  163.                     sigs = Wait( my_noti_port_mask | my_test_port_mask | window_mask | my_time_mask_clock | (1L << not_sig) | SIGBREAKF_CTRL_C | SIGBREAKF_CTRL_D | cxsigflag );
  164.                     if (sigs & my_time_mask_clock)
  165.                     {
  166.                     if(data->win)
  167.                     {
  168.                         do_what=do_clock;
  169.                         mem_val++;
  170.                         if(mem_val>=set->mem_refresh)
  171.                         {
  172.                         mem_val=0;
  173.                         do_what=do_mem;
  174.                         }
  175.                         vol_val++;
  176.                         if(vol_val>=set->vol_refresh)
  177.                         {
  178.                         vol_val=0;
  179.                         do_what=do_vol;
  180.                         }
  181.                         for(i=0,many=data->list;i<data->num_of_gaug;i++,many=many->next)
  182.                         {
  183.                         if(data->gdg[i]!=0)
  184.                         switch (do_what)
  185.                         {
  186.                             case    do_vol:
  187.                                 if(many->type==typ_volume)
  188.                                 {
  189.                                 getVolsize(data,&many->expansion[0]);
  190.                                 SetAttrs(data->gdg[i],GAU_VolType,data->voltype,GAU_Max,data->volmax,GAU_Current,data->volcur,TAG_DONE);
  191.                                 BeginRefresh(data->win);
  192.                                 EndRefresh(data->win,TRUE);
  193.                                 RefreshGList(data->gdg[i], data->win,NULL,1);
  194.                                 }
  195.                             case    do_mem:
  196.                                 switch (many->type)
  197.                                 {
  198.                                 case    typ_all:
  199.                                     cur=AvailMem(0L);
  200.                                     break;
  201.                                 case    typ_chip:
  202.                                     cur=AvailMem(MEMF_CHIP);
  203.                                     break;
  204.                                 case    typ_fast:
  205.                                     cur=AvailMem(MEMF_FAST);
  206.                                     break;
  207.                                 case    typ_idle:
  208.                                     GetAttr(GAU_Current,data->gdg[i],&bas);
  209.                                     switch (data->executive)
  210.                                     {
  211.                                         case    idle_none:
  212.                                             cur=0L;
  213.                                             break;
  214.                                         case    idle_executive:
  215.                                             GetCpuUsage(data->si,&data->cpu);
  216.                                             cur=(data->cpu.used_cputime_lastsec_hz-data->cpu.used_cputime_lastsec)<<8;
  217.                                             break;
  218.                                         case    idle_own:
  219.                                             cur=idle;
  220.                                             break;
  221.                                     }
  222.                                     if(bas<cur)SetAttrs(data->gdg[i],GAU_Base,cur,TAG_DONE);
  223.                                     break;
  224.                                 case    typ_largest_total:
  225.                                     cur=AvailMem(MEMF_LARGEST);
  226.                                     break;
  227.                                 case    typ_largest_chip:
  228.                                     cur=AvailMem(MEMF_LARGEST|MEMF_CHIP);
  229.                                     break;
  230.                                 case    typ_largest_fast:
  231.                                     cur=AvailMem(MEMF_LARGEST|MEMF_FAST);
  232.                                     break;
  233.                                 case    typ_largest_retina:
  234.                                     if(RetinaBase)
  235.                                         cur=Retina_AvailMem(MEMF_LARGEST);
  236.                                     else
  237.                                         cur=GAU_err_notavail;
  238.                                     break;
  239.                                 case    typ_retina:
  240.                                     if(RetinaBase)
  241.                                         cur=Retina_AvailMem(0L);
  242.                                     else
  243.                                         cur=GAU_err_notavail;
  244.                                     break;
  245.                                 default:
  246.                                     goto none_4;
  247.                                     break;
  248.                                 }
  249.                                 if(do_what!=do_vol)
  250.                                 {
  251.                                 SetAttrs(data->gdg[i],GAU_Current,cur,TAG_DONE);
  252.                                 BeginRefresh(data->win);
  253.                                 EndRefresh(data->win,TRUE);
  254.                                 RefreshGList(data->gdg[i],data->win,NULL,1);
  255.                                 }
  256.                                 none_4:
  257.                             case    do_clock:
  258.                                 if(many->type==typ_clock_)
  259.                                 {
  260.                                 SetAttrs(data->gdg[i],GAU_Current,cur,TAG_DONE);
  261.                                 BeginRefresh(data->win);
  262.                                 EndRefresh(data->win,TRUE);
  263.                                 RefreshGList(data->gdg[i],data->win,NULL,1);
  264.                                 }
  265.                                 break;
  266.                         }
  267.                         }
  268.                         if(first_run){setBase(data);first_run=FALSE;}
  269.                     }
  270.                     if(set->win_backfront==win_front)
  271.                     {
  272.                         if(data->win->WLayer!=data->scr->LayerInfo.top_layer)
  273.                         WindowToFront(data->win);
  274.                     }
  275.                     init_time_request(my_time_request_clock,my_time_mask_clock);
  276.                     }
  277.                     if (sigs & window_mask )
  278.                     {
  279.                     while(m=(struct IntuiMessage *)GetMsg( data->win->UserPort ))
  280.                     {
  281.                         switch ( m->Class )
  282.                         {
  283.                         case    IDCMP_CHANGEWINDOW:
  284.                             if(set->bg_type==bg_snap)
  285.                             {
  286.                                 ReplyMsg( m );
  287.                                 while((m=(struct IntuiMessage *)GetMsg( data->win->UserPort )))ReplyMsg( m );
  288.                                 window_mask=snapSub(set,data);
  289.                                 goto no_Reply;
  290.                             }
  291.                             break;
  292.                         case    IDCMP_CLOSEWINDOW:
  293.                             running=FALSE;
  294.                             break;
  295.                         case    IDCMP_NEWSIZE:
  296.                             {
  297.                                 new_window_size(set,data);
  298.                                 set->x_siz=data->win->Width;
  299.                                 data->gauge_x_size=(set->x_siz-(set->win_border_x<<1)-((set->colums-1)*set->win_space_x))/set->colums;
  300.                                 switch (set->bg_type)
  301.                                 {
  302.                                 case    bg_file:
  303.                                     fileBackground(set,data);
  304.                                     break;
  305.                                 case    bg_snap:
  306.                                     ReplyMsg( m );
  307.                                     while((m=(struct IntuiMessage *)GetMsg( data->win->UserPort )))ReplyMsg( m );
  308.                                     g=data->win->FirstGadget;
  309.                                     data->win=(struct Window *)snapBackground(set,data);
  310.                                     RemoveGList(data->win,data->win->FirstGadget,-1);
  311.                                     AddGList(data->win,g,0,-1,NULL);
  312.                                     window_mask  = 1L << data->win->UserPort->mp_SigBit;
  313.                                     break;
  314.                                 default:
  315.                                     break;
  316.                                 }
  317.                                 drawBackground(set,data);
  318.                                 for(i=0,many=data->list;i<data->num_of_gaug;i++,many=many->next)
  319.                                 {
  320.                                 if(data->gdg[i]!=0)
  321.                                 {
  322.                                     SetAttrs(data->gdg[i],
  323.                                          GA_Left,        set->win_border_x+((i)%set->colums)*data->gauge_x_size+((i)%set->colums)*set->win_space_x,
  324.                                          GA_Width,       data->gauge_x_size,
  325.                                          TAG_DONE);
  326.                                     RefreshGList(data->gdg[i], data->win,NULL,1);
  327.                                 }                                                                
  328.                                 }
  329.                             }
  330.                             if(set->bg_type==bg_snap) goto no_Reply;
  331.                             break;
  332.                         case    IDCMP_VANILLAKEY:
  333.                             switch(m->Code)
  334.                             {
  335.                                 case    'S':
  336.                                 case    's':
  337.                                     {
  338.                                     set->x_pos=data->win->LeftEdge;
  339.                                     set->y_pos=data->win->TopEdge;
  340.                                     set->x_siz=data->win->Width;
  341.                                     if(my_file=(UBYTE *)Open("ENV:TinyMeter",MODE_NEWFILE))
  342.                                     {
  343.                                         Write(my_file,set,(ULONG) sizeof(struct tm_sys_set));
  344.                                         many=data->list;
  345.                                         for(i=0;i<data->num_of_gaug;i++)
  346.                                         {
  347.                                         Write(my_file,many,(ULONG) sizeof(struct tm_gau_set));
  348.                                         many=many->next;
  349.                                         }
  350.                                         Close(my_file);
  351.                                     }
  352.                                     if(my_file=(UBYTE *)Open("ENVARC:TinyMeter",MODE_NEWFILE))
  353.                                     {
  354.                                         Write(my_file,set,(ULONG) sizeof(struct tm_sys_set));
  355.                                         many=data->list;
  356.                                         for(i=0;i<data->num_of_gaug;i++)
  357.                                         {
  358.                                         Write(my_file,many,(ULONG) sizeof(struct tm_gau_set));
  359.                                         many=many->next;
  360.                                         }
  361.                                         Close(my_file);
  362.                                     }
  363.                                     }
  364.                                     break;
  365.                                 case    'F':
  366.                                 case    'f':
  367.                                     {
  368.                                     ULONG   my_mem;
  369.                                     Forbid();
  370.                                     my_mem= AllocVec(2000000000L,MEMF_PUBLIC);
  371.                                     if(my_mem)FreeVec(my_mem);
  372.                                     Permit();
  373.                                     }
  374.                                     break;
  375.                                 case    'Q':
  376.                                 case    'q':
  377.                                     running=FALSE;
  378.                                     break;
  379.                                 case    'b':
  380.                                 case    'B':
  381.                                     if(set->bg_type==bg_snap)
  382.                                     {
  383.                                     ReplyMsg( m );
  384.                                     while((m=(struct IntuiMessage *)GetMsg( data->win->UserPort )))ReplyMsg( m );
  385.                                     window_mask=snapSub(set,data);
  386.                                     goto no_Reply;
  387.                                     }
  388.                                     break;
  389.                             }
  390.                             break;
  391.                         case    IDCMP_MOUSEBUTTONS:
  392.                             if((m->Code&129)==1)
  393.                             {
  394.                                 setBase(data);
  395.                             }
  396.                             break;
  397.                         default :
  398.                             break;
  399.                         }
  400.                         ReplyMsg( m );
  401. no_Reply:
  402.                     }
  403.                     }
  404.                     if (sigs & (1L << not_sig))
  405.                     {
  406.                     Delay(100L);
  407.                     switch (set->bg_type)
  408.                     {
  409.                         case    bg_snap:
  410.                             window_mask=snapSub(set,data);
  411.                             break;
  412.                         default:
  413.                             break;
  414.                     }
  415.                     }
  416.                     if (sigs & cxsigflag)
  417.                     {
  418.                     CxMsg *msg;
  419.                     ULONG sigrcvd, msgid, msgtype;
  420.  
  421.                     while(msg = (CxMsg *)GetMsg(broker_mp))
  422.                     {
  423.                         msgid = CxMsgID(msg);
  424.                         msgtype = CxMsgType(msg);
  425.                         if(msgtype==CXM_COMMAND)
  426.                         switch(msgid)
  427.                         {
  428.                         case    CXCMD_DISABLE:
  429.                             {
  430.                                 BOOL pause=TRUE;
  431.                                 ActivateCxObj(broker, 0L);
  432.                                 while(pause)
  433.                                 {
  434.                                 Wait(cxsigflag);
  435.                                 while(msg = (CxMsg *)GetMsg(broker_mp))
  436.                                 {
  437.                                     msgid = CxMsgID(msg);
  438.                                     msgtype = CxMsgType(msg);
  439.                                     ReplyMsg((struct Message *)msg);
  440.                                     if(msgtype==CXM_COMMAND) if(msgid==CXCMD_ENABLE) pause=FALSE;
  441.                                 }
  442.                                 }
  443.                                 ActivateCxObj(broker, 1L);
  444.                             }
  445.                             break;
  446.                         case    CXCMD_ENABLE:
  447.                             ActivateCxObj(broker, 1L);
  448.                             break;
  449.                         case    CXCMD_KILL:
  450.                             running=FALSE;
  451.                             break;
  452.                         }
  453.                         ReplyMsg((struct Message *)msg);
  454.                     }
  455.                     }
  456.                     if ((sigs & my_test_port_mask))
  457.                     {
  458.                     while(test_msg=(struct TestMessage *)GetMsg(my_test_port))
  459.                     {
  460.                         switch (test_msg->MethodID)
  461.                         {
  462.                         case    test_test:
  463.                             closeWindow(set,data);
  464.                             removeGadgets(set,data);
  465.                             first_run=TRUE;
  466.                             if(test_msg->set && test_msg->list)
  467.                             {
  468.                                 FreeVec(set);
  469.                                 many=data->list;
  470.                                 do
  471.                                 {
  472.                                 next=many->next;
  473.                                 FreeVec(many);
  474.                                 }
  475.                                 while(many=next);
  476.                                 set                 = test_msg->set;
  477.                                 data->list          = test_msg->list;
  478.                                 data->num_of_gaug   = getNum(data->list);
  479.                             }
  480.                             if(openWindow(set,data))
  481.                             {
  482.                                 drawBackground(set,data);
  483.                                 allocGadgets(set,data,gclass);
  484.                                 window_mask  = 1L << data->win->UserPort->mp_SigBit;
  485.                             }
  486.                             else running=FALSE;
  487.                             setBase(data);
  488.                             break;
  489.                         case    test_getwin:
  490.                             test_msg->posx=data->win->LeftEdge;
  491.                             test_msg->posy=data->win->TopEdge;
  492.                             test_msg->sizx=data->win->Width;
  493.                             break;
  494.                         }
  495.                         ReplyMsg(test_msg);
  496.                     }
  497.                     }
  498.                     if(data->scrnot)
  499.                     {
  500.                     if (sigs & my_noti_port_mask)
  501.                     {
  502.                         struct ScreenNotifyMessage  *snm;
  503.                         while(snm = (struct ScreenNotifyMessage *) GetMsg(my_noti_port))
  504.                         {
  505.                         switch(snm->snm_Type)
  506.                         {
  507.                             case    SCREENNOTIFY_TYPE_CLOSESCREEN:
  508.                                 ReplyMsg((struct Message *) snm);
  509.                                 running=FALSE;
  510.                                 break;
  511.                             case    SCREENNOTIFY_TYPE_WORKBENCH:
  512.                                 switch ((ULONG)snm->snm_Value)
  513.                                 {
  514.                                 case    FALSE:
  515.                                     closeWindow(set,data);
  516.                                     removeGadgets(set,data);
  517.                                     ReplyMsg((struct Message *) snm);
  518.                                     Wait(my_noti_port_mask);
  519.                                     while(snm = (struct ScreenNotifyMessage *) GetMsg(my_noti_port))
  520.                                     {
  521.                                         if(snm->snm_Type==SCREENNOTIFY_TYPE_WORKBENCH)
  522.                                         {
  523.                                         if((ULONG)snm->snm_Value==TRUE)
  524.                                         {
  525.                                             ReplyMsg((struct Message *) snm);
  526.                                             Delay(50L);
  527.                                             if(openWindow(set,data))
  528.                                             {
  529.                                             drawBackground(set,data);
  530.                                             allocGadgets(set,data,gclass);
  531.                                             window_mask  = 1L << data->win->UserPort->mp_SigBit;
  532.                                             }
  533.                                             else running=FALSE;
  534.                                             setBase(data);
  535.                                         }
  536.                                         else running=FALSE;
  537.                                         }
  538.                                         else running=FALSE;
  539.                                     }
  540.                                     first_run=TRUE;
  541.                                     break;
  542.                                 default:
  543.                                     ReplyMsg((struct Message *) snm);
  544.                                     break;
  545.                                 }
  546.                                 break;
  547.                             default:
  548.                                 ReplyMsg((struct Message *) snm);
  549.                                 break;
  550.                         }
  551.                         }
  552.                     }
  553.                     Delay(10L);
  554.                     }
  555.                     if (sigs & (SIGBREAKF_CTRL_C | SIGBREAKF_CTRL_D)) running=FALSE;
  556.                 }
  557.                 }
  558.                 else show("StartNotify failed!");
  559.                 FreeSignal(not_sig);
  560.             }
  561.             else show("Could not allocate signal!");
  562.             FreeVec(notifyrequest);
  563.             }
  564.             else show("Not enough memory!");
  565.             if(!CheckIO(my_time_request_clock))
  566.             AbortIO(my_time_request_clock);
  567.             WaitIO(my_time_request_clock);
  568.             CloseDevice(my_time_request_clock);
  569.         }
  570.         else show("timer.device usage failed!");
  571.         DeleteIORequest(my_time_request_clock);
  572.         }
  573.         else show("CreateIORequest failed!");
  574.         DeleteMsgPort(my_time_port_clock);
  575.     }
  576.     else show("CreateMsgPort failed!");
  577.     DeletePort(my_test_port);
  578.     }
  579.     else show("CreatePort failed.!");
  580.  
  581.     if(data->scrnot)
  582.     {
  583.     if((!data->on_public)|(!strcmp(&set->pub_name[0],"Workbench")))
  584.         while(!RemWorkbenchClient(my_handler)) Delay(10);
  585.     else
  586.         while(!RemCloseScreenClient(my_handler)) Delay(10);
  587.     DeleteMsgPort(my_noti_port);
  588.     }
  589.  
  590.     return(set);
  591. }
  592.  
  593.